'Weak Dependency Graph [60.0]' ------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , top(mark(X)) -> top(proper(X)) , top(ok(X)) -> top(active(X))} Details: We have computed the following set of weak (innermost) dependency pairs: { active^#(U11(tt(), M, N)) -> c_0(U12^#(tt(), M, N)) , active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M))) , active^#(plus(N, 0())) -> c_2() , active^#(plus(N, s(M))) -> c_3(U11^#(tt(), M, N)) , active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3)) , active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3)) , active^#(s(X)) -> c_6(s^#(active(X))) , active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2)) , active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2))) , U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3)) , U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3)) , s^#(mark(X)) -> c_11(s^#(X)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2)) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3))) , proper^#(tt()) -> c_15() , proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3))) , proper^#(s(X)) -> c_17(s^#(proper(X))) , proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2))) , proper^#(0()) -> c_19() , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , top^#(mark(X)) -> c_24(top^#(proper(X))) , top^#(ok(X)) -> c_25(top^#(active(X)))} The usable rules are: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} The estimated dependency graph contains the following edges: {active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M)))} ==> {s^#(ok(X)) -> c_22(s^#(X))} {active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M)))} ==> {s^#(mark(X)) -> c_11(s^#(X))} {active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3))} ==> {U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} {active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3))} ==> {U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3))} {active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3))} ==> {U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3))} {active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3))} ==> {U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} {active^#(s(X)) -> c_6(s^#(active(X)))} ==> {s^#(ok(X)) -> c_22(s^#(X))} {active^#(s(X)) -> c_6(s^#(active(X)))} ==> {s^#(mark(X)) -> c_11(s^#(X))} {active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2))} ==> {plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} {active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2))} ==> {plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2))} {active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2))} ==> {plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} {active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2)))} ==> {plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} {active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2)))} ==> {plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2))} {active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2)))} ==> {plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} {U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3))} ==> {U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} {U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3))} ==> {U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3))} {U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} ==> {U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3))} {U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} ==> {U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} {s^#(mark(X)) -> c_11(s^#(X))} ==> {s^#(ok(X)) -> c_22(s^#(X))} {s^#(mark(X)) -> c_11(s^#(X))} ==> {s^#(mark(X)) -> c_11(s^#(X))} {plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} ==> {plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} {plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} ==> {plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2))} {plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} ==> {plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} {plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2))} ==> {plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} {plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2))} ==> {plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2))} {plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2))} ==> {plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} {proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3)))} ==> {U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} {proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3)))} ==> {U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3))} {proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3)))} ==> {U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3))} {proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3)))} ==> {U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} {proper^#(s(X)) -> c_17(s^#(proper(X)))} ==> {s^#(ok(X)) -> c_22(s^#(X))} {proper^#(s(X)) -> c_17(s^#(proper(X)))} ==> {s^#(mark(X)) -> c_11(s^#(X))} {proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2)))} ==> {plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} {proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2)))} ==> {plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2))} {proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2)))} ==> {plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} {U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} ==> {U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} {U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} ==> {U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3))} {U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3))} ==> {U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3))} {U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3))} ==> {U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} {s^#(ok(X)) -> c_22(s^#(X))} ==> {s^#(ok(X)) -> c_22(s^#(X))} {s^#(ok(X)) -> c_22(s^#(X))} ==> {s^#(mark(X)) -> c_11(s^#(X))} {plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} ==> {plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} {plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} ==> {plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2))} {plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} ==> {plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} {top^#(mark(X)) -> c_24(top^#(proper(X)))} ==> {top^#(ok(X)) -> c_25(top^#(active(X)))} {top^#(mark(X)) -> c_24(top^#(proper(X)))} ==> {top^#(mark(X)) -> c_24(top^#(proper(X)))} {top^#(ok(X)) -> c_25(top^#(active(X)))} ==> {top^#(ok(X)) -> c_25(top^#(active(X)))} {top^#(ok(X)) -> c_25(top^#(active(X)))} ==> {top^#(mark(X)) -> c_24(top^#(proper(X)))} We consider the following path(s): 1) { top^#(mark(X)) -> c_24(top^#(proper(X))) , top^#(ok(X)) -> c_25(top^#(active(X)))} The usable rules for this path are the following: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , top^#(mark(X)) -> c_24(top^#(proper(X))) , top^#(ok(X)) -> c_25(top^#(active(X)))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [1] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {top^#(mark(X)) -> c_24(top^#(proper(X)))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {top^#(mark(X)) -> c_24(top^#(proper(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [1] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} and weakly orienting the rules { top^#(mark(X)) -> c_24(top^#(proper(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [1] c_24(x1) = [1] x1 + [0] c_25(x1) = [1] x1 + [1] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(plus(N, 0())) -> mark(N)} and weakly orienting the rules { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , top^#(mark(X)) -> c_24(top^#(proper(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(plus(N, 0())) -> mark(N)} Details: Interpretation Functions: active(x1) = [1] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [14] tt() = [14] mark(x1) = [1] x1 + [15] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [14] s(x1) = [1] x1 + [4] plus(x1, x2) = [1] x1 + [1] x2 + [14] 0() = [8] proper(x1) = [1] x1 + [8] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [1] c_24(x1) = [1] x1 + [0] c_25(x1) = [1] x1 + [7] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(plus(N, s(M))) -> mark(U11(tt(), M, N))} and weakly orienting the rules { active(plus(N, 0())) -> mark(N) , proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , top^#(mark(X)) -> c_24(top^#(proper(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(plus(N, s(M))) -> mark(U11(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [8] plus(x1, x2) = [1] x1 + [1] x2 + [10] 0() = [0] proper(x1) = [1] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [1] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} and weakly orienting the rules { active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , top^#(mark(X)) -> c_24(top^#(proper(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} Details: Interpretation Functions: active(x1) = [1] x1 + [4] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [5] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [8] proper(x1) = [1] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [1] c_24(x1) = [1] x1 + [0] c_25(x1) = [1] x1 + [1] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {top^#(ok(X)) -> c_25(top^#(active(X)))} and weakly orienting the rules { active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , top^#(mark(X)) -> c_24(top^#(proper(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {top^#(ok(X)) -> c_25(top^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [8] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [14] s(x1) = [1] x1 + [2] plus(x1, x2) = [1] x1 + [1] x2 + [5] 0() = [9] proper(x1) = [1] x1 + [8] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [1] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { top^#(ok(X)) -> c_25(top^#(active(X))) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , top^#(mark(X)) -> c_24(top^#(proper(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { top^#(ok(X)) -> c_25(top^#(active(X))) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , top^#(mark(X)) -> c_24(top^#(proper(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { active_0(2) -> 4 , tt_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , proper_0(2) -> 6 , ok_0(2) -> 2 , ok_0(2) -> 6 , top^#_0(2) -> 1 , top^#_0(4) -> 3 , top^#_0(6) -> 5 , c_24_0(5) -> 1 , c_25_0(3) -> 1 , c_25_0(3) -> 5} 2) { active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} The usable rules for this path are the following: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [1] x1 + [1] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [1] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [1] c_13(x1) = [1] x1 + [1] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2))} and weakly orienting the rules { active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [1] c_13(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2))} and weakly orienting the rules { plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [1] c_13(x1) = [1] x1 + [1] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} and weakly orienting the rules { active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2)) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [6] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [11] s(x1) = [1] x1 + [3] plus(x1, x2) = [1] x1 + [1] x2 + [2] 0() = [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [6] c_13(x1) = [1] x1 + [1] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} and weakly orienting the rules { active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2)) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [5] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [4] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2)) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2)) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , ok_0(2) -> 2 , active^#_0(2) -> 1 , plus^#_0(2, 2) -> 1 , c_12_0(1) -> 1 , c_13_0(1) -> 1 , c_23_0(1) -> 1} 3) { active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2))) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} The usable rules for this path are the following: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2))) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [1] x1 + [1] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [1] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [1] c_13(x1) = [1] x1 + [1] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2))} and weakly orienting the rules { active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [1] c_13(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2)))} and weakly orienting the rules { plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [1] c_13(x1) = [1] x1 + [1] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} and weakly orienting the rules { active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2))) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [6] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [11] s(x1) = [1] x1 + [3] plus(x1, x2) = [1] x1 + [1] x2 + [2] 0() = [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [6] c_13(x1) = [1] x1 + [1] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} and weakly orienting the rules { active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2))) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [5] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [4] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2))) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2))) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , ok_0(2) -> 2 , active^#_0(2) -> 1 , plus^#_0(2, 2) -> 1 , c_12_0(1) -> 1 , c_13_0(1) -> 1 , c_23_0(1) -> 1} 4) { active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3)) , U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} The usable rules for this path are the following: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3)) , U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} Details: We apply the weight gap principle, strictly orienting the rules {U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [1] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3))} and weakly orienting the rules {U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [12] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [2] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [7] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3)) , U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [9] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [7] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [5] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(plus(N, 0())) -> mark(N)} and weakly orienting the rules { active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3)) , U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(plus(N, 0())) -> mark(N)} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [1] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [1] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [1] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(plus(N, s(M))) -> mark(U11(tt(), M, N))} and weakly orienting the rules { active(plus(N, 0())) -> mark(N) , active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3)) , U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(plus(N, s(M))) -> mark(U11(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [1] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [12] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [1] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [1] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} and weakly orienting the rules { active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3)) , U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} Details: Interpretation Functions: active(x1) = [1] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [8] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [1] 0() = [9] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [5] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [4] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} and weakly orienting the rules { active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3)) , U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [8] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3)) , U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3)) , U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , ok_0(2) -> 2 , active^#_0(2) -> 1 , U12^#_0(2, 2, 2) -> 1 , c_10_0(1) -> 1 , c_21_0(1) -> 1} 5) { active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3)) , U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3))} The usable rules for this path are the following: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3)) , U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [9] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3))} and weakly orienting the rules { U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [1] x1 + [1] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(plus(N, s(M))) -> mark(U11(tt(), M, N))} and weakly orienting the rules { active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3)) , U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(plus(N, s(M))) -> mark(U11(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [8] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(plus(N, 0())) -> mark(N)} and weakly orienting the rules { active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3)) , U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(plus(N, 0())) -> mark(N)} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [8] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} and weakly orienting the rules { active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3)) , U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [4] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [12] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] c_4(x1) = [1] x1 + [5] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} and weakly orienting the rules { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3)) , U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [6] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3)) , U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3)) , U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , ok_0(2) -> 2 , active^#_0(2) -> 1 , U11^#_0(2, 2, 2) -> 1 , c_9_0(1) -> 1 , c_20_0(1) -> 1} 6) { active^#(s(X)) -> c_6(s^#(active(X))) , s^#(ok(X)) -> c_22(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} The usable rules for this path are the following: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , active^#(s(X)) -> c_6(s^#(active(X))) , s^#(ok(X)) -> c_22(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [12] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {s^#(mark(X)) -> c_11(s^#(X))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {s^#(mark(X)) -> c_11(s^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [12] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [1] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [1] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [4] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(s(X)) -> c_6(s^#(active(X)))} and weakly orienting the rules { s^#(mark(X)) -> c_11(s^#(X)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(s(X)) -> c_6(s^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [9] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [7] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [7] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(plus(N, s(M))) -> mark(U11(tt(), M, N))} and weakly orienting the rules { active^#(s(X)) -> c_6(s^#(active(X))) , s^#(mark(X)) -> c_11(s^#(X)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(plus(N, s(M))) -> mark(U11(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [1] mark(x1) = [1] x1 + [4] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [6] plus(x1, x2) = [1] x1 + [1] x2 + [2] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [1] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(plus(N, 0())) -> mark(N)} and weakly orienting the rules { active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(s(X)) -> c_6(s^#(active(X))) , s^#(mark(X)) -> c_11(s^#(X)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(plus(N, 0())) -> mark(N)} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [1] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [2] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} and weakly orienting the rules { active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(s(X)) -> c_6(s^#(active(X))) , s^#(mark(X)) -> c_11(s^#(X)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [1] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [1] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [1] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(s(X)) -> c_6(s^#(active(X))) , s^#(mark(X)) -> c_11(s^#(X)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(s(X)) -> c_6(s^#(active(X))) , s^#(mark(X)) -> c_11(s^#(X)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 3 , mark_0(3) -> 4 , mark_0(4) -> 4 , mark_0(8) -> 4 , mark_0(10) -> 4 , 0_0() -> 8 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(8) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(8) -> 12 , active^#_0(10) -> 12 , s^#_0(3) -> 16 , s^#_0(4) -> 16 , s^#_0(8) -> 16 , s^#_0(10) -> 16 , c_11_0(16) -> 16 , c_22_0(16) -> 16} 7) {active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3))} The usable rules for this path are the following: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [8] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [4] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [4] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [2] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(plus(N, s(M))) -> mark(U11(tt(), M, N))} and weakly orienting the rules { active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(plus(N, s(M))) -> mark(U11(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [8] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(plus(N, 0())) -> mark(N)} and weakly orienting the rules { active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(plus(N, 0())) -> mark(N)} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [12] plus(x1, x2) = [1] x1 + [1] x2 + [2] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} and weakly orienting the rules { active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [7] 0() = [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [2] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} and weakly orienting the rules { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(U12(X1, X2, X3)) -> c_5(U12^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 3 , mark_0(3) -> 4 , mark_0(4) -> 4 , mark_0(8) -> 4 , mark_0(10) -> 4 , 0_0() -> 8 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(8) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(8) -> 12 , active^#_0(10) -> 12 , U12^#_0(3, 3, 3) -> 14 , U12^#_0(3, 3, 4) -> 14 , U12^#_0(3, 3, 8) -> 14 , U12^#_0(3, 3, 10) -> 14 , U12^#_0(3, 4, 3) -> 14 , U12^#_0(3, 4, 4) -> 14 , U12^#_0(3, 4, 8) -> 14 , U12^#_0(3, 4, 10) -> 14 , U12^#_0(3, 8, 3) -> 14 , U12^#_0(3, 8, 4) -> 14 , U12^#_0(3, 8, 8) -> 14 , U12^#_0(3, 8, 10) -> 14 , U12^#_0(3, 10, 3) -> 14 , U12^#_0(3, 10, 4) -> 14 , U12^#_0(3, 10, 8) -> 14 , U12^#_0(3, 10, 10) -> 14 , U12^#_0(4, 3, 3) -> 14 , U12^#_0(4, 3, 4) -> 14 , U12^#_0(4, 3, 8) -> 14 , U12^#_0(4, 3, 10) -> 14 , U12^#_0(4, 4, 3) -> 14 , U12^#_0(4, 4, 4) -> 14 , U12^#_0(4, 4, 8) -> 14 , U12^#_0(4, 4, 10) -> 14 , U12^#_0(4, 8, 3) -> 14 , U12^#_0(4, 8, 4) -> 14 , U12^#_0(4, 8, 8) -> 14 , U12^#_0(4, 8, 10) -> 14 , U12^#_0(4, 10, 3) -> 14 , U12^#_0(4, 10, 4) -> 14 , U12^#_0(4, 10, 8) -> 14 , U12^#_0(4, 10, 10) -> 14 , U12^#_0(8, 3, 3) -> 14 , U12^#_0(8, 3, 4) -> 14 , U12^#_0(8, 3, 8) -> 14 , U12^#_0(8, 3, 10) -> 14 , U12^#_0(8, 4, 3) -> 14 , U12^#_0(8, 4, 4) -> 14 , U12^#_0(8, 4, 8) -> 14 , U12^#_0(8, 4, 10) -> 14 , U12^#_0(8, 8, 3) -> 14 , U12^#_0(8, 8, 4) -> 14 , U12^#_0(8, 8, 8) -> 14 , U12^#_0(8, 8, 10) -> 14 , U12^#_0(8, 10, 3) -> 14 , U12^#_0(8, 10, 4) -> 14 , U12^#_0(8, 10, 8) -> 14 , U12^#_0(8, 10, 10) -> 14 , U12^#_0(10, 3, 3) -> 14 , U12^#_0(10, 3, 4) -> 14 , U12^#_0(10, 3, 8) -> 14 , U12^#_0(10, 3, 10) -> 14 , U12^#_0(10, 4, 3) -> 14 , U12^#_0(10, 4, 4) -> 14 , U12^#_0(10, 4, 8) -> 14 , U12^#_0(10, 4, 10) -> 14 , U12^#_0(10, 8, 3) -> 14 , U12^#_0(10, 8, 4) -> 14 , U12^#_0(10, 8, 8) -> 14 , U12^#_0(10, 8, 10) -> 14 , U12^#_0(10, 10, 3) -> 14 , U12^#_0(10, 10, 4) -> 14 , U12^#_0(10, 10, 8) -> 14 , U12^#_0(10, 10, 10) -> 14} 8) {active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3))} The usable rules for this path are the following: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [4] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [2] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(plus(N, s(M))) -> mark(U11(tt(), M, N))} and weakly orienting the rules { active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(plus(N, s(M))) -> mark(U11(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [8] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(plus(N, 0())) -> mark(N)} and weakly orienting the rules { active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(plus(N, 0())) -> mark(N)} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [12] plus(x1, x2) = [1] x1 + [1] x2 + [2] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} and weakly orienting the rules { active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} Details: Interpretation Functions: active(x1) = [1] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [2] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [5] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [2] 0() = [2] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [8] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [1] x1 + [1] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} and weakly orienting the rules { active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [1] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [5] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(U11(X1, X2, X3)) -> c_4(U11^#(active(X1), X2, X3)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 3 , mark_0(3) -> 4 , mark_0(4) -> 4 , mark_0(8) -> 4 , mark_0(10) -> 4 , 0_0() -> 8 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(8) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(8) -> 12 , active^#_0(10) -> 12 , U11^#_0(3, 3, 3) -> 19 , U11^#_0(3, 3, 4) -> 19 , U11^#_0(3, 3, 8) -> 19 , U11^#_0(3, 3, 10) -> 19 , U11^#_0(3, 4, 3) -> 19 , U11^#_0(3, 4, 4) -> 19 , U11^#_0(3, 4, 8) -> 19 , U11^#_0(3, 4, 10) -> 19 , U11^#_0(3, 8, 3) -> 19 , U11^#_0(3, 8, 4) -> 19 , U11^#_0(3, 8, 8) -> 19 , U11^#_0(3, 8, 10) -> 19 , U11^#_0(3, 10, 3) -> 19 , U11^#_0(3, 10, 4) -> 19 , U11^#_0(3, 10, 8) -> 19 , U11^#_0(3, 10, 10) -> 19 , U11^#_0(4, 3, 3) -> 19 , U11^#_0(4, 3, 4) -> 19 , U11^#_0(4, 3, 8) -> 19 , U11^#_0(4, 3, 10) -> 19 , U11^#_0(4, 4, 3) -> 19 , U11^#_0(4, 4, 4) -> 19 , U11^#_0(4, 4, 8) -> 19 , U11^#_0(4, 4, 10) -> 19 , U11^#_0(4, 8, 3) -> 19 , U11^#_0(4, 8, 4) -> 19 , U11^#_0(4, 8, 8) -> 19 , U11^#_0(4, 8, 10) -> 19 , U11^#_0(4, 10, 3) -> 19 , U11^#_0(4, 10, 4) -> 19 , U11^#_0(4, 10, 8) -> 19 , U11^#_0(4, 10, 10) -> 19 , U11^#_0(8, 3, 3) -> 19 , U11^#_0(8, 3, 4) -> 19 , U11^#_0(8, 3, 8) -> 19 , U11^#_0(8, 3, 10) -> 19 , U11^#_0(8, 4, 3) -> 19 , U11^#_0(8, 4, 4) -> 19 , U11^#_0(8, 4, 8) -> 19 , U11^#_0(8, 4, 10) -> 19 , U11^#_0(8, 8, 3) -> 19 , U11^#_0(8, 8, 4) -> 19 , U11^#_0(8, 8, 8) -> 19 , U11^#_0(8, 8, 10) -> 19 , U11^#_0(8, 10, 3) -> 19 , U11^#_0(8, 10, 4) -> 19 , U11^#_0(8, 10, 8) -> 19 , U11^#_0(8, 10, 10) -> 19 , U11^#_0(10, 3, 3) -> 19 , U11^#_0(10, 3, 4) -> 19 , U11^#_0(10, 3, 8) -> 19 , U11^#_0(10, 3, 10) -> 19 , U11^#_0(10, 4, 3) -> 19 , U11^#_0(10, 4, 4) -> 19 , U11^#_0(10, 4, 8) -> 19 , U11^#_0(10, 4, 10) -> 19 , U11^#_0(10, 8, 3) -> 19 , U11^#_0(10, 8, 4) -> 19 , U11^#_0(10, 8, 8) -> 19 , U11^#_0(10, 8, 10) -> 19 , U11^#_0(10, 10, 3) -> 19 , U11^#_0(10, 10, 4) -> 19 , U11^#_0(10, 10, 8) -> 19 , U11^#_0(10, 10, 10) -> 19} 9) {active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2)))} The usable rules for this path are the following: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2)))} Details: We apply the weight gap principle, strictly orienting the rules { active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [2] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2)))} and weakly orienting the rules { active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [1] x1 + [3] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(plus(N, 0())) -> mark(N)} and weakly orienting the rules { active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2))) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(plus(N, 0())) -> mark(N)} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [8] plus(x1, x2) = [1] x1 + [1] x2 + [2] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} and weakly orienting the rules { active(plus(N, 0())) -> mark(N) , active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2))) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [9] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [8] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [8] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} and weakly orienting the rules { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2))) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [3] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2))) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active^#(plus(X1, X2)) -> c_8(plus^#(X1, active(X2))) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 3 , mark_0(3) -> 4 , mark_0(4) -> 4 , mark_0(8) -> 4 , mark_0(10) -> 4 , 0_0() -> 8 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(8) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(8) -> 12 , active^#_0(10) -> 12 , plus^#_0(3, 3) -> 24 , plus^#_0(3, 4) -> 24 , plus^#_0(3, 8) -> 24 , plus^#_0(3, 10) -> 24 , plus^#_0(4, 3) -> 24 , plus^#_0(4, 4) -> 24 , plus^#_0(4, 8) -> 24 , plus^#_0(4, 10) -> 24 , plus^#_0(8, 3) -> 24 , plus^#_0(8, 4) -> 24 , plus^#_0(8, 8) -> 24 , plus^#_0(8, 10) -> 24 , plus^#_0(10, 3) -> 24 , plus^#_0(10, 4) -> 24 , plus^#_0(10, 8) -> 24 , plus^#_0(10, 10) -> 24} 10) {active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2))} The usable rules for this path are the following: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2))} Details: We apply the weight gap principle, strictly orienting the rules { active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [2] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2))} and weakly orienting the rules { active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [3] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(plus(N, 0())) -> mark(N)} and weakly orienting the rules { active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2)) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(plus(N, 0())) -> mark(N)} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [8] plus(x1, x2) = [1] x1 + [1] x2 + [2] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} and weakly orienting the rules { active(plus(N, 0())) -> mark(N) , active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2)) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), M, N)) -> mark(U12(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [9] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [8] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [8] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} and weakly orienting the rules { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2)) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [3] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2)) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(plus(N, 0())) -> mark(N) , active^#(plus(X1, X2)) -> c_7(plus^#(active(X1), X2)) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 3 , mark_0(3) -> 4 , mark_0(4) -> 4 , mark_0(8) -> 4 , mark_0(10) -> 4 , 0_0() -> 8 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(8) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(8) -> 12 , active^#_0(10) -> 12 , plus^#_0(3, 3) -> 24 , plus^#_0(3, 4) -> 24 , plus^#_0(3, 8) -> 24 , plus^#_0(3, 10) -> 24 , plus^#_0(4, 3) -> 24 , plus^#_0(4, 4) -> 24 , plus^#_0(4, 8) -> 24 , plus^#_0(4, 10) -> 24 , plus^#_0(8, 3) -> 24 , plus^#_0(8, 4) -> 24 , plus^#_0(8, 8) -> 24 , plus^#_0(8, 10) -> 24 , plus^#_0(10, 3) -> 24 , plus^#_0(10, 4) -> 24 , plus^#_0(10, 8) -> 24 , plus^#_0(10, 10) -> 24} 11) { proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3))) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3)) , U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3))} The usable rules for this path are the following: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3))) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3)) , U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [4] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [5] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_14(x1) = [1] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3)))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [4] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_14(x1) = [1] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} and weakly orienting the rules { proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_14(x1) = [1] x1 + [5] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3))} and weakly orienting the rules { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [4] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [4] proper(x1) = [1] x1 + [2] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [5] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [3] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [11] c_14(x1) = [1] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3)) , proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { U11^#(mark(X1), X2, X3) -> c_9(U11^#(X1, X2, X3)) , proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U11^#(ok(X1), ok(X2), ok(X3)) -> c_20(U11^#(X1, X2, X3))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , ok_0(2) -> 2 , U11^#_0(2, 2, 2) -> 1 , c_9_0(1) -> 1 , proper^#_0(2) -> 1 , c_20_0(1) -> 1} 12) { proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2))) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} The usable rules for this path are the following: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2))) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2)) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [1] c_13(x1) = [1] x1 + [1] proper^#(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [1] x1 + [1] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2)))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [3] c_13(x1) = [1] x1 + [0] proper^#(x1) = [1] x1 + [9] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [1] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} and weakly orienting the rules { proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [8] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [2] c_13(x1) = [1] x1 + [1] proper^#(x1) = [1] x1 + [9] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [1] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} and weakly orienting the rules { plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2)) , proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [1] x1 + [0] proper^#(x1) = [1] x1 + [15] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [1] x1 + [13] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2)) , proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , plus^#(X1, mark(X2)) -> c_13(plus^#(X1, X2)) , plus^#(mark(X1), X2) -> c_12(plus^#(X1, X2)) , proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , plus^#(ok(X1), ok(X2)) -> c_23(plus^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , ok_0(2) -> 2 , plus^#_0(2, 2) -> 1 , c_12_0(1) -> 1 , c_13_0(1) -> 1 , proper^#_0(2) -> 1 , c_23_0(1) -> 1} 13) { proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3))) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3)) , U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} The usable rules for this path are the following: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3))) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3)) , U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [1] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [1] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [1] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3)))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [4] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [1] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [1] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} and weakly orienting the rules { proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [8] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [5] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [4] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [1] x1 + [1] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} and weakly orienting the rules { U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3)) , proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [3] mark(x1) = [1] x1 + [8] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [4] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [1] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3)) , proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , U12^#(mark(X1), X2, X3) -> c_10(U12^#(X1, X2, X3)) , proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , U12^#(ok(X1), ok(X2), ok(X3)) -> c_21(U12^#(X1, X2, X3))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , ok_0(2) -> 2 , U12^#_0(2, 2, 2) -> 1 , c_10_0(1) -> 1 , proper^#_0(2) -> 1 , c_21_0(1) -> 1} 14) {active^#(s(X)) -> c_6(s^#(active(X)))} The usable rules for this path are the following: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , active^#(s(X)) -> c_6(s^#(active(X)))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [10] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(s(X)) -> c_6(s^#(active(X)))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(s(X)) -> c_6(s^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [9] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [3] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N))} and weakly orienting the rules { active^#(s(X)) -> c_6(s^#(active(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [8] plus(x1, x2) = [1] x1 + [1] x2 + [2] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [1] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [1] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} and weakly orienting the rules { active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(s(X)) -> c_6(s^#(active(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M)))} Details: Interpretation Functions: active(x1) = [1] x1 + [8] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [8] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [5] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [11] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [1] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(s(X)) -> c_6(s^#(active(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(U11(X1, X2, X3)) -> U11(active(X1), X2, X3) , active(U12(X1, X2, X3)) -> U12(active(X1), X2, X3) , active(s(X)) -> s(active(X)) , active(plus(X1, X2)) -> plus(active(X1), X2) , active(plus(X1, X2)) -> plus(X1, active(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), M, N)) -> mark(U12(tt(), M, N)) , active(U12(tt(), M, N)) -> mark(s(plus(N, M))) , active(plus(N, 0())) -> mark(N) , active(plus(N, s(M))) -> mark(U11(tt(), M, N)) , active^#(s(X)) -> c_6(s^#(active(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 3 , mark_0(3) -> 4 , mark_0(4) -> 4 , mark_0(8) -> 4 , mark_0(10) -> 4 , 0_0() -> 8 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(8) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(8) -> 12 , active^#_0(10) -> 12 , s^#_0(3) -> 16 , s^#_0(4) -> 16 , s^#_0(8) -> 16 , s^#_0(10) -> 16} 15) { proper^#(s(X)) -> c_17(s^#(proper(X))) , s^#(ok(X)) -> c_22(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} The usable rules for this path are the following: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , proper^#(s(X)) -> c_17(s^#(proper(X))) , s^#(ok(X)) -> c_22(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [1] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [1] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [4] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [1] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [1] x1 + [1] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(s(X)) -> c_17(s^#(proper(X)))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(s(X)) -> c_17(s^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [2] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [1] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} and weakly orienting the rules { proper^#(s(X)) -> c_17(s^#(proper(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [5] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [1] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , proper^#(s(X)) -> c_17(s^#(proper(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , proper^#(s(X)) -> c_17(s^#(proper(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s^#(ok(X)) -> c_22(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 3 , mark_0(3) -> 4 , mark_0(4) -> 4 , mark_0(8) -> 4 , mark_0(10) -> 4 , 0_0() -> 8 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(8) -> 10 , ok_0(10) -> 10 , s^#_0(3) -> 16 , s^#_0(4) -> 16 , s^#_0(8) -> 16 , s^#_0(10) -> 16 , c_11_0(16) -> 16 , proper^#_0(3) -> 31 , proper^#_0(4) -> 31 , proper^#_0(8) -> 31 , proper^#_0(10) -> 31 , c_22_0(16) -> 16} 16) {proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3)))} The usable rules for this path are the following: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3)))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [1] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3)))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [1] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} and weakly orienting the rules { proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [1] mark(x1) = [1] x1 + [8] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [8] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [1] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , proper^#(U12(X1, X2, X3)) -> c_16(U12^#(proper(X1), proper(X2), proper(X3))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 3 , mark_0(3) -> 4 , mark_0(4) -> 4 , mark_0(8) -> 4 , mark_0(10) -> 4 , 0_0() -> 8 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(8) -> 10 , ok_0(10) -> 10 , U12^#_0(3, 3, 3) -> 14 , U12^#_0(3, 3, 4) -> 14 , U12^#_0(3, 3, 8) -> 14 , U12^#_0(3, 3, 10) -> 14 , U12^#_0(3, 4, 3) -> 14 , U12^#_0(3, 4, 4) -> 14 , U12^#_0(3, 4, 8) -> 14 , U12^#_0(3, 4, 10) -> 14 , U12^#_0(3, 8, 3) -> 14 , U12^#_0(3, 8, 4) -> 14 , U12^#_0(3, 8, 8) -> 14 , U12^#_0(3, 8, 10) -> 14 , U12^#_0(3, 10, 3) -> 14 , U12^#_0(3, 10, 4) -> 14 , U12^#_0(3, 10, 8) -> 14 , U12^#_0(3, 10, 10) -> 14 , U12^#_0(4, 3, 3) -> 14 , U12^#_0(4, 3, 4) -> 14 , U12^#_0(4, 3, 8) -> 14 , U12^#_0(4, 3, 10) -> 14 , U12^#_0(4, 4, 3) -> 14 , U12^#_0(4, 4, 4) -> 14 , U12^#_0(4, 4, 8) -> 14 , U12^#_0(4, 4, 10) -> 14 , U12^#_0(4, 8, 3) -> 14 , U12^#_0(4, 8, 4) -> 14 , U12^#_0(4, 8, 8) -> 14 , U12^#_0(4, 8, 10) -> 14 , U12^#_0(4, 10, 3) -> 14 , U12^#_0(4, 10, 4) -> 14 , U12^#_0(4, 10, 8) -> 14 , U12^#_0(4, 10, 10) -> 14 , U12^#_0(8, 3, 3) -> 14 , U12^#_0(8, 3, 4) -> 14 , U12^#_0(8, 3, 8) -> 14 , U12^#_0(8, 3, 10) -> 14 , U12^#_0(8, 4, 3) -> 14 , U12^#_0(8, 4, 4) -> 14 , U12^#_0(8, 4, 8) -> 14 , U12^#_0(8, 4, 10) -> 14 , U12^#_0(8, 8, 3) -> 14 , U12^#_0(8, 8, 4) -> 14 , U12^#_0(8, 8, 8) -> 14 , U12^#_0(8, 8, 10) -> 14 , U12^#_0(8, 10, 3) -> 14 , U12^#_0(8, 10, 4) -> 14 , U12^#_0(8, 10, 8) -> 14 , U12^#_0(8, 10, 10) -> 14 , U12^#_0(10, 3, 3) -> 14 , U12^#_0(10, 3, 4) -> 14 , U12^#_0(10, 3, 8) -> 14 , U12^#_0(10, 3, 10) -> 14 , U12^#_0(10, 4, 3) -> 14 , U12^#_0(10, 4, 4) -> 14 , U12^#_0(10, 4, 8) -> 14 , U12^#_0(10, 4, 10) -> 14 , U12^#_0(10, 8, 3) -> 14 , U12^#_0(10, 8, 4) -> 14 , U12^#_0(10, 8, 8) -> 14 , U12^#_0(10, 8, 10) -> 14 , U12^#_0(10, 10, 3) -> 14 , U12^#_0(10, 10, 4) -> 14 , U12^#_0(10, 10, 8) -> 14 , U12^#_0(10, 10, 10) -> 14 , proper^#_0(3) -> 31 , proper^#_0(4) -> 31 , proper^#_0(8) -> 31 , proper^#_0(10) -> 31} 17) {proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3)))} The usable rules for this path are the following: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3)))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_14(x1) = [1] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3)))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_14(x1) = [1] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} and weakly orienting the rules { proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [1] mark(x1) = [1] x1 + [8] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [8] c_14(x1) = [1] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , proper^#(U11(X1, X2, X3)) -> c_14(U11^#(proper(X1), proper(X2), proper(X3))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 3 , mark_0(3) -> 4 , mark_0(4) -> 4 , mark_0(8) -> 4 , mark_0(10) -> 4 , 0_0() -> 8 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(8) -> 10 , ok_0(10) -> 10 , U11^#_0(3, 3, 3) -> 19 , U11^#_0(3, 3, 4) -> 19 , U11^#_0(3, 3, 8) -> 19 , U11^#_0(3, 3, 10) -> 19 , U11^#_0(3, 4, 3) -> 19 , U11^#_0(3, 4, 4) -> 19 , U11^#_0(3, 4, 8) -> 19 , U11^#_0(3, 4, 10) -> 19 , U11^#_0(3, 8, 3) -> 19 , U11^#_0(3, 8, 4) -> 19 , U11^#_0(3, 8, 8) -> 19 , U11^#_0(3, 8, 10) -> 19 , U11^#_0(3, 10, 3) -> 19 , U11^#_0(3, 10, 4) -> 19 , U11^#_0(3, 10, 8) -> 19 , U11^#_0(3, 10, 10) -> 19 , U11^#_0(4, 3, 3) -> 19 , U11^#_0(4, 3, 4) -> 19 , U11^#_0(4, 3, 8) -> 19 , U11^#_0(4, 3, 10) -> 19 , U11^#_0(4, 4, 3) -> 19 , U11^#_0(4, 4, 4) -> 19 , U11^#_0(4, 4, 8) -> 19 , U11^#_0(4, 4, 10) -> 19 , U11^#_0(4, 8, 3) -> 19 , U11^#_0(4, 8, 4) -> 19 , U11^#_0(4, 8, 8) -> 19 , U11^#_0(4, 8, 10) -> 19 , U11^#_0(4, 10, 3) -> 19 , U11^#_0(4, 10, 4) -> 19 , U11^#_0(4, 10, 8) -> 19 , U11^#_0(4, 10, 10) -> 19 , U11^#_0(8, 3, 3) -> 19 , U11^#_0(8, 3, 4) -> 19 , U11^#_0(8, 3, 8) -> 19 , U11^#_0(8, 3, 10) -> 19 , U11^#_0(8, 4, 3) -> 19 , U11^#_0(8, 4, 4) -> 19 , U11^#_0(8, 4, 8) -> 19 , U11^#_0(8, 4, 10) -> 19 , U11^#_0(8, 8, 3) -> 19 , U11^#_0(8, 8, 4) -> 19 , U11^#_0(8, 8, 8) -> 19 , U11^#_0(8, 8, 10) -> 19 , U11^#_0(8, 10, 3) -> 19 , U11^#_0(8, 10, 4) -> 19 , U11^#_0(8, 10, 8) -> 19 , U11^#_0(8, 10, 10) -> 19 , U11^#_0(10, 3, 3) -> 19 , U11^#_0(10, 3, 4) -> 19 , U11^#_0(10, 3, 8) -> 19 , U11^#_0(10, 3, 10) -> 19 , U11^#_0(10, 4, 3) -> 19 , U11^#_0(10, 4, 4) -> 19 , U11^#_0(10, 4, 8) -> 19 , U11^#_0(10, 4, 10) -> 19 , U11^#_0(10, 8, 3) -> 19 , U11^#_0(10, 8, 4) -> 19 , U11^#_0(10, 8, 8) -> 19 , U11^#_0(10, 8, 10) -> 19 , U11^#_0(10, 10, 3) -> 19 , U11^#_0(10, 10, 4) -> 19 , U11^#_0(10, 10, 8) -> 19 , U11^#_0(10, 10, 10) -> 19 , proper^#_0(3) -> 31 , proper^#_0(4) -> 31 , proper^#_0(8) -> 31 , proper^#_0(10) -> 31} 18) {proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2)))} The usable rules for this path are the following: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2)))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [1] x1 + [1] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2)))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [2] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [8] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [1] x1 + [1] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} and weakly orienting the rules { proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [2] tt() = [0] mark(x1) = [1] x1 + [14] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [1] x1 + [1] x2 + [2] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [8] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [1] x1 + [3] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , proper^#(plus(X1, X2)) -> c_18(plus^#(proper(X1), proper(X2))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 3 , mark_0(3) -> 4 , mark_0(4) -> 4 , mark_0(8) -> 4 , mark_0(10) -> 4 , 0_0() -> 8 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(8) -> 10 , ok_0(10) -> 10 , plus^#_0(3, 3) -> 24 , plus^#_0(3, 4) -> 24 , plus^#_0(3, 8) -> 24 , plus^#_0(3, 10) -> 24 , plus^#_0(4, 3) -> 24 , plus^#_0(4, 4) -> 24 , plus^#_0(4, 8) -> 24 , plus^#_0(4, 10) -> 24 , plus^#_0(8, 3) -> 24 , plus^#_0(8, 4) -> 24 , plus^#_0(8, 8) -> 24 , plus^#_0(8, 10) -> 24 , plus^#_0(10, 3) -> 24 , plus^#_0(10, 4) -> 24 , plus^#_0(10, 8) -> 24 , plus^#_0(10, 10) -> 24 , proper^#_0(3) -> 31 , proper^#_0(4) -> 31 , proper^#_0(8) -> 31 , proper^#_0(10) -> 31} 19) {proper^#(s(X)) -> c_17(s^#(proper(X)))} The usable rules for this path are the following: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3)) , s(ok(X)) -> ok(s(X)) , proper^#(s(X)) -> c_17(s^#(proper(X)))} Details: We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [1] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(s(X)) -> c_17(s^#(proper(X)))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(s(X)) -> c_17(s^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [8] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [3] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [1] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} and weakly orienting the rules { proper^#(s(X)) -> c_17(s^#(proper(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [2] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [5] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [1] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , proper^#(s(X)) -> c_17(s^#(proper(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(U11(X1, X2, X3)) -> U11(proper(X1), proper(X2), proper(X3)) , proper(U12(X1, X2, X3)) -> U12(proper(X1), proper(X2), proper(X3)) , proper(s(X)) -> s(proper(X)) , proper(plus(X1, X2)) -> plus(proper(X1), proper(X2)) , plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , U11(mark(X1), X2, X3) -> mark(U11(X1, X2, X3)) , U12(mark(X1), X2, X3) -> mark(U12(X1, X2, X3)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(tt()) -> ok(tt()) , proper(0()) -> ok(0()) , proper^#(s(X)) -> c_17(s^#(proper(X))) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , U11(ok(X1), ok(X2), ok(X3)) -> ok(U11(X1, X2, X3)) , U12(ok(X1), ok(X2), ok(X3)) -> ok(U12(X1, X2, X3))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 3 , mark_0(3) -> 4 , mark_0(4) -> 4 , mark_0(8) -> 4 , mark_0(10) -> 4 , 0_0() -> 8 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(8) -> 10 , ok_0(10) -> 10 , s^#_0(3) -> 16 , s^#_0(4) -> 16 , s^#_0(8) -> 16 , s^#_0(10) -> 16 , proper^#_0(3) -> 31 , proper^#_0(4) -> 31 , proper^#_0(8) -> 31 , proper^#_0(10) -> 31} 20) { active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M))) , s^#(ok(X)) -> c_22(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} The usable rules for this path are the following: { plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M))) , s^#(ok(X)) -> c_22(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} Details: We apply the weight gap principle, strictly orienting the rules {active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M)))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [0] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [1] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [1] x1 + [1] s^#(x1) = [1] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [4] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , s^#(ok(X)) -> c_22(s^#(X))} and weakly orienting the rules {active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , s^#(ok(X)) -> c_22(s^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [0] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [1] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [3] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [1] x1 + [0] s^#(x1) = [1] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {s^#(mark(X)) -> c_11(s^#(X))} and weakly orienting the rules { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , s^#(ok(X)) -> c_22(s^#(X)) , active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {s^#(mark(X)) -> c_11(s^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [8] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [3] s(x1) = [0] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [1] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [8] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [1] x1 + [1] s^#(x1) = [1] x1 + [8] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2))} Weak Rules: { s^#(mark(X)) -> c_11(s^#(X)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , s^#(ok(X)) -> c_22(s^#(X)) , active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M)))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2))} Weak Rules: { s^#(mark(X)) -> c_11(s^#(X)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , s^#(ok(X)) -> c_22(s^#(X)) , active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M)))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 3 , mark_0(3) -> 4 , mark_0(4) -> 4 , mark_0(10) -> 4 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(10) -> 12 , s^#_0(3) -> 16 , s^#_0(4) -> 16 , s^#_0(10) -> 16 , c_11_0(16) -> 16 , c_22_0(16) -> 16} 21) {active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M)))} The usable rules for this path are the following: { plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2)) , plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M)))} Details: We apply the weight gap principle, strictly orienting the rules {active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M)))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [0] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [1] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [1] x1 + [0] s^#(x1) = [1] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {plus(ok(X1), ok(X2)) -> ok(plus(X1, X2))} and weakly orienting the rules {active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {plus(ok(X1), ok(X2)) -> ok(plus(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] tt() = [0] mark(x1) = [1] x1 + [0] U12(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] s(x1) = [0] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [1] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [1] x1 + [0] s^#(x1) = [1] x1 + [2] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2))} Weak Rules: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M)))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { plus(mark(X1), X2) -> mark(plus(X1, X2)) , plus(X1, mark(X2)) -> mark(plus(X1, X2))} Weak Rules: { plus(ok(X1), ok(X2)) -> ok(plus(X1, X2)) , active^#(U12(tt(), M, N)) -> c_1(s^#(plus(N, M)))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { tt_0() -> 3 , mark_0(3) -> 4 , mark_0(4) -> 4 , mark_0(10) -> 4 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(10) -> 12 , s^#_0(3) -> 16 , s^#_0(4) -> 16 , s^#_0(10) -> 16} 22) {active^#(plus(N, s(M))) -> c_3(U11^#(tt(), M, N))} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] tt() = [0] mark(x1) = [0] x1 + [0] U12(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] s(x1) = [0] x1 + [0] plus(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {active^#(plus(N, s(M))) -> c_3(U11^#(tt(), M, N))} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {active^#(plus(N, s(M))) -> c_3(U11^#(tt(), M, N))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(plus(N, s(M))) -> c_3(U11^#(tt(), M, N))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] tt() = [0] mark(x1) = [0] x1 + [0] U12(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] s(x1) = [1] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [1] x1 + [0] U11^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {active^#(plus(N, s(M))) -> c_3(U11^#(tt(), M, N))} Details: The given problem does not contain any strict rules 23) {active^#(U11(tt(), M, N)) -> c_0(U12^#(tt(), M, N))} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] tt() = [0] mark(x1) = [0] x1 + [0] U12(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] s(x1) = [0] x1 + [0] plus(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {active^#(U11(tt(), M, N)) -> c_0(U12^#(tt(), M, N))} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {active^#(U11(tt(), M, N)) -> c_0(U12^#(tt(), M, N))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U11(tt(), M, N)) -> c_0(U12^#(tt(), M, N))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] tt() = [0] mark(x1) = [0] x1 + [0] U12(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] s(x1) = [0] x1 + [0] plus(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [1] x1 + [0] U12^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {active^#(U11(tt(), M, N)) -> c_0(U12^#(tt(), M, N))} Details: The given problem does not contain any strict rules 24) {active^#(plus(N, 0())) -> c_2()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] tt() = [0] mark(x1) = [0] x1 + [0] U12(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] s(x1) = [0] x1 + [0] plus(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {active^#(plus(N, 0())) -> c_2()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {active^#(plus(N, 0())) -> c_2()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(plus(N, 0())) -> c_2()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] tt() = [0] mark(x1) = [0] x1 + [0] U12(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] s(x1) = [0] x1 + [0] plus(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {active^#(plus(N, 0())) -> c_2()} Details: The given problem does not contain any strict rules 25) {proper^#(tt()) -> c_15()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] tt() = [0] mark(x1) = [0] x1 + [0] U12(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] s(x1) = [0] x1 + [0] plus(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {proper^#(tt()) -> c_15()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {proper^#(tt()) -> c_15()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(tt()) -> c_15()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] tt() = [0] mark(x1) = [0] x1 + [0] U12(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] s(x1) = [0] x1 + [0] plus(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {proper^#(tt()) -> c_15()} Details: The given problem does not contain any strict rules 26) {proper^#(0()) -> c_19()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] tt() = [0] mark(x1) = [0] x1 + [0] U12(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] s(x1) = [0] x1 + [0] plus(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {proper^#(0()) -> c_19()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {proper^#(0()) -> c_19()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(0()) -> c_19()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] U11(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] tt() = [0] mark(x1) = [0] x1 + [0] U12(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] s(x1) = [0] x1 + [0] plus(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] U12^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_1(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U11^#(x1, x2, x3) = [0] x1 + [0] x2 + [0] x3 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] plus^#(x1, x2) = [0] x1 + [0] x2 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17(x1) = [0] x1 + [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {proper^#(0()) -> c_19()} Details: The given problem does not contain any strict rules